package com.up.management.service.impl;

import java.util.List;
import java.util.ArrayList;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import com.up.management.mapper.ItemMapper;
import com.up.management.mapper.ItemDetailMapper;
import com.up.management.mapper.ItemCategoryMapper;
import com.up.management.mapper.ItemRegionMapper;
import com.up.management.domain.entity.Item;
import com.up.management.domain.entity.ItemDetail;
import com.up.management.domain.entity.ItemCategory;
import com.up.management.domain.entity.ItemRegion;
import com.up.management.domain.dto.ItemDetailDTO;
import com.up.management.domain.dto.ItemWithDetailDTO;
import com.up.management.domain.vo.ItemVO;
import com.up.management.domain.vo.ItemDetailVO;
import com.up.management.service.IItemService;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.core.type.TypeReference;
import com.up.common.utils.StringUtils;

/**
 * 项目管理Service业务层处理
 * 
 * @author cloud
 * @date 2025-09-18
 */
@Service
public class ItemServiceImpl implements IItemService 
{
    @Autowired
    private ItemMapper itemMapper;

    @Autowired
    private ItemDetailMapper itemDetailMapper;

    @Autowired
    private ItemCategoryMapper itemCategoryMapper;

    @Autowired
    private ItemRegionMapper itemRegionMapper;

    /**
     * 查询项目管理
     * 
     * @param id 项目管理主键
     * @return 项目管理
     */
    @Override
    public Item selectItemById(Long id)
    {
        return itemMapper.selectItemById(id);
    }

    /**
     * 查询项目管理（返回VO）
     * 
     * @param id 项目管理主键
     * @return 项目管理VO
     */
    @Override
    public ItemVO selectItemVOById(Long id)
    {
        Item item = itemMapper.selectItemById(id);
        if (item == null) {
            return null;
        }
        
        ItemVO itemVO = new ItemVO();
        BeanUtils.copyProperties(item, itemVO);
        
        // 设置分类名称
        if (item.getCategoryId() != null) {
            ItemCategory category = itemCategoryMapper.selectItemCategoryById(item.getCategoryId());
            if (category != null) {
                itemVO.setCategoryName(category.getName());
            }
        }
        
        // 设置地区名称
        if (item.getRegionId() != null) {
            ItemRegion region = itemRegionMapper.selectItemRegionById(item.getRegionId());
            if (region != null) {
                itemVO.setRegionName(region.getName());
            }
        }
        
        // 设置状态描述
        itemVO.setStatusText(getStatusText(item.getStatus()));
        
        return itemVO;
    }

    /**
     * 查询项目管理列表
     * 
     * @param item 项目管理
     * @return 项目管理
     */
    @Override
    public List<Item> selectItemList(Item item)
    {
        return itemMapper.selectItemList(item);
    }

    /**
     * 查询项目管理列表（返回VO）
     * 
     * @param item 项目管理
     * @return 项目管理VO集合
     */
    @Override
    public List<ItemVO> selectItemVOList(Item item)
    {
        List<Item> itemList = itemMapper.selectItemList(item);
        List<ItemVO> itemVOList = new ArrayList<>();
        
        for (Item itemEntity : itemList) {
            ItemVO itemVO = new ItemVO();
            BeanUtils.copyProperties(itemEntity, itemVO);
            
            // 设置分类名称
            if (itemEntity.getCategoryId() != null) {
                ItemCategory category = itemCategoryMapper.selectItemCategoryById(itemEntity.getCategoryId());
                if (category != null) {
                    itemVO.setCategoryName(category.getName());
                }
            }
            
            // 设置地区名称
            if (itemEntity.getRegionId() != null) {
                ItemRegion region = itemRegionMapper.selectItemRegionById(itemEntity.getRegionId());
                if (region != null) {
                    itemVO.setRegionName(region.getName());
                }
            }
            
            // 设置状态描述
            itemVO.setStatusText(getStatusText(itemEntity.getStatus()));
            
            itemVOList.add(itemVO);
        }
        
        return itemVOList;
    }

    /**
     * 新增项目管理
     * 
     * @param item 项目管理
     * @return 结果
     */
    @Override
    public int insertItem(Item item)
    {
        return itemMapper.insertItem(item);
    }

    /**
     * 修改项目管理
     * 
     * @param item 项目管理
     * @return 结果
     */
    @Override
    public int updateItem(Item item)
    {
        return itemMapper.updateItem(item);
    }

    /**
     * 批量删除项目管理
     * 
     * @param ids 需要删除的项目管理主键
     * @return 结果
     */
    @Override
    public int deleteItemByIds(Long[] ids)
    {
        return itemMapper.deleteItemByIds(ids);
    }

    /**
     * 删除项目管理信息
     * 
     * @param id 项目管理主键
     * @return 结果
     */
    @Override
    public int deleteItemById(Long id)
    {
        return itemMapper.deleteItemById(id);
    }

    /**
     * 查询项目详情（包含详细信息）
     * 
     * @param id 项目管理主键
     * @return 项目详情
     */
    @Override
    public ItemDetailDTO selectItemDetailById(Long id)
    {
        return itemDetailMapper.selectItemDetailDTOByItemId(id);
    }

    /**
     * 查询项目详情（返回VO）
     * 
     * @param id 项目管理主键
     * @return 项目详情VO
     */
    @Override
    public ItemDetailVO selectItemDetailVOById(Long id)
    {
        Item item = itemMapper.selectItemById(id);
        if (item == null) {
            return null;
        }
        
        ItemDetail itemDetail = itemDetailMapper.selectItemDetailByItemId(id);
        
        ItemDetailVO itemDetailVO = new ItemDetailVO();
        BeanUtils.copyProperties(item, itemDetailVO);
        
        if (itemDetail != null) {
            itemDetailVO.setDescription(itemDetail.getDescription());
            itemDetailVO.setViewCount(itemDetail.getViewCount());
            
            // 处理图片和视频字段，转换为List
            if (StringUtils.isNotEmpty(itemDetail.getImages())) {
                try {
                    ObjectMapper objectMapper = new ObjectMapper();
                    List<String> imagesList = objectMapper.readValue(itemDetail.getImages(), new TypeReference<List<String>>(){});
                    itemDetailVO.setImages(imagesList);
                } catch (Exception e) {
                    // 如果解析失败，设置为空列表
                    itemDetailVO.setImages(new ArrayList<>());
                }
            }
            
            if (StringUtils.isNotEmpty(itemDetail.getVideos())) {
                try {
                    ObjectMapper objectMapper = new ObjectMapper();
                    List<String> videosList = objectMapper.readValue(itemDetail.getVideos(), new TypeReference<List<String>>(){});
                    itemDetailVO.setVideos(videosList);
                } catch (Exception e) {
                    // 如果解析失败，设置为空列表
                    itemDetailVO.setVideos(new ArrayList<>());
                }
            }
        }
        
        // 设置分类名称
        if (item.getCategoryId() != null) {
            ItemCategory category = itemCategoryMapper.selectItemCategoryById(item.getCategoryId());
            if (category != null) {
                itemDetailVO.setCategoryName(category.getName());
            }
        }
        
        // 设置地区名称
        if (item.getRegionId() != null) {
            ItemRegion region = itemRegionMapper.selectItemRegionById(item.getRegionId());
            if (region != null) {
                itemDetailVO.setRegionName(region.getName());
            }
        }
        
        // 设置状态描述
        itemDetailVO.setStatusText(getStatusText(item.getStatus()));
        
        return itemDetailVO;
    }

    /**
     * 新增项目管理（包含详情）
     * 
     * @param itemWithDetail 项目管理（包含详情）
     * @return 结果
     */
    @Override
    public int insertItemWithDetail(ItemWithDetailDTO itemWithDetail)
    {
        // 1. 先插入基本项目信息
        int result = itemMapper.insertItem(itemWithDetail);
        
        // 2. 如果有详情信息，则插入详情
        if (itemWithDetail.getItemDetail() != null && result > 0)
        {
            ItemDetail itemDetail = itemWithDetail.getItemDetail();
            itemDetail.setItemId(itemWithDetail.getId());
            
            // 处理images和videos字段，确保存储为规范的JSON数组格式
            processImagesAndVideos(itemDetail);
            
            int detailResult = itemDetailMapper.insertItemDetail(itemDetail);
            // 如果详情插入失败，返回0表示整体操作失败
            if (detailResult <= 0) {
                return 0;
            }
        }
        
        return result;
    }

    /**
     * 修改项目管理（包含详情）
     * 
     * @param itemWithDetail 项目管理（包含详情）
     * @return 结果
     */
    @Override
    public int updateItemWithDetail(ItemWithDetailDTO itemWithDetail)
    {
        // 1. 先更新基本项目信息
        int result = itemMapper.updateItem(itemWithDetail);
        
        // 2. 处理详情信息
        if (itemWithDetail.getItemDetail() != null && result > 0)
        {
            ItemDetail itemDetail = itemWithDetail.getItemDetail();
            itemDetail.setItemId(itemWithDetail.getId());
            
            // 处理images和videos字段，确保存储为规范的JSON数组格式
            processImagesAndVideos(itemDetail);
            
            // 检查是否已存在详情记录
            ItemDetail existingDetail = itemDetailMapper.selectItemDetailByItemId(itemWithDetail.getId());
            if (existingDetail != null)
            {
                // 更新现有详情
                itemDetail.setId(existingDetail.getId());
                itemDetailMapper.updateItemDetail(itemDetail);
            }
            else
            {
                // 插入新详情
                itemDetailMapper.insertItemDetail(itemDetail);
            }
        }
        
        return result;
    }
    
    /**
     * 处理images和videos字段，确保存储为规范的JSON数组格式
     * 
     * @param itemDetail 项目详情对象
     */
    private void processImagesAndVideos(ItemDetail itemDetail) {
        // 处理images字段
        if (StringUtils.isNotEmpty(itemDetail.getImages())) {
            itemDetail.setImages(processStringToJsonArray(itemDetail.getImages()));
        }
        
        // 处理videos字段
        if (StringUtils.isNotEmpty(itemDetail.getVideos())) {
            itemDetail.setVideos(processStringToJsonArray(itemDetail.getVideos()));
        }
    }
    
    /**
     * 将字符串转换为规范的JSON数组格式
     * 
     * @param str 输入字符串（可能是JSON数组或逗号分隔的字符串）
     * @return 规范的JSON数组字符串
     */
    private String processStringToJsonArray(String str) {
        if (StringUtils.isEmpty(str)) {
            return "[]";
        }
        
        try {
            ObjectMapper objectMapper = new ObjectMapper();
            List<String> resultList;
            String trimmedStr = str.trim();
            
            // 如果已经是JSON数组格式，先解析再重新序列化（去除多余的转义字符）
            if (trimmedStr.startsWith("[") && trimmedStr.endsWith("]")) {
                resultList = objectMapper.readValue(trimmedStr, new TypeReference<List<String>>() {});
            } else {
                // 如果是逗号分隔的字符串，转换为数组
                String[] itemsArray = trimmedStr.split(",");
                resultList = new ArrayList<>();
                for (String item : itemsArray) {
                    String trimmedItem = item.trim();
                    if (StringUtils.isNotEmpty(trimmedItem)) {
                        resultList.add(trimmedItem);
                    }
                }
            }
            
            // 转换为规范的JSON数组格式（不会产生多余的转义字符）
            return objectMapper.writeValueAsString(resultList);
        } catch (Exception e) {
            // 如果处理失败，返回空数组
            e.printStackTrace();
            return "[]";
        }
    }

    /**
     * 获取状态描述
     * 
     * @param status 状态值
     * @return 状态描述
     */
    private String getStatusText(Long status) {
        if (status == null) {
            return "未知";
        }
        
        switch (status.intValue()) {
            case 0:
                return "禁用";
            case 1:
                return "启用";
            case 2:
                return "审核中";
            default:
                return "未知";
        }
    }
}
